home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / umich / telecomm / fnordadl / fn132src.zoo / citutil / makezt.c < prev    next >
C/C++ Source or Header  |  1991-09-02  |  8KB  |  346 lines
  1. /*
  2.  * makezt.c -- Create zaploop tables
  3.  *
  4.  * 91Jan03 AA    Hacked up to know about the new nodename, gen & lastid fields
  5.  * 88Jul04 orc    Fixed (patriotically)
  6.  * 88Jun20 orc    Created.
  7.  */
  8.  
  9. #include "ctdl.h"
  10. #include "zaploop.h"
  11. #include "msg.h"
  12. #include "room.h"
  13. #include "config.h"
  14. #include "citlib.h"
  15.  
  16. #ifdef TEST
  17. char inNet = YES;
  18. char loggedIn = NO;
  19. #endif
  20.  
  21. char *program = "makezt";
  22.  
  23. static struct zaploop zapnode;
  24. static int zapdbx;
  25. static short zapcur = ERROR;
  26. static struct mupdate {
  27.     time_t mulast;        /* newest message found here... (date) */
  28.     long mulastid;        /* highest message id found here */
  29.     short muloc;        /* bucket for this message    */
  30. } *nzmsg;
  31. static int nzsize;
  32.  
  33. char checkloops = 1;
  34.  
  35. time_t today;    /* holds current time for compares against msg time/dates */
  36.  
  37. #ifdef TEST
  38. /*
  39.  * decoy routines to avoid linker hysterics
  40.  */
  41. mprintf() {}
  42. mAbort() {}
  43. xprintf() {}
  44.  
  45. /*
  46.  * decoy variables to avoid linker hysterics
  47.  */
  48. char haveCarrier;
  49. char usingWCprotocol = 0;
  50. char echo;
  51. int (*sendPFchar)();
  52. #endif
  53.  
  54. /*
  55.  * normID() -- Normalizes a node id.
  56.  */
  57. int
  58. normID(LABEL source, LABEL dest)
  59. {
  60.     while (!isalpha(*source) && *source)
  61.     source++;
  62.     if (!*source) return NO;
  63.     *dest++ = toupper(*source++);
  64.     while (!isalpha(*source) && *source)
  65.     source++;
  66.     if (!*source) return NO;
  67.     *dest++ = toupper(*source++);
  68.     while (*source) {
  69.     if (isdigit(*source))
  70.         *dest++ = *source;
  71.     source++;
  72.     }
  73.     *dest = 0;
  74.     return YES;
  75. }
  76.  
  77. /*
  78.  * roomAt() -- what room is this?
  79.  */
  80. int
  81. roomAt(char *rmname)
  82. {
  83.     for (thisRoom = AIDEROOM + 1; thisRoom < MAXROOMS; thisRoom++)
  84.     if (stricmp(roomTab[thisRoom].rtname, rmname) == 0)
  85.         return thisRoom;
  86.     return thisRoom = ERROR;
  87. }
  88.  
  89. /*
  90.  * init_zap() - open the zaploop database
  91.  */
  92. void
  93. init_zap(void)
  94. {
  95.     PATHBUF zapfile;
  96.  
  97.     ctdlfile(zapfile, cfg.netdir, "ctdlloop.zap");
  98.  
  99.     dunlink(zapfile);
  100.     if ((zapdbx = dcreat(zapfile)) < 0)
  101.     crashout("cannot open %s\n", zapfile);
  102.     nzmsg = (struct mupdate *)malloc(sizeof *nzmsg);
  103.     nzsize = 0;
  104. }
  105.  
  106. static void
  107. getx(short i)
  108. {
  109.     zapcur = i;
  110.     dseek(zapdbx, zapcur * sizeof zapnode, SEEK_SET);
  111.     dread(zapdbx, &zapnode, sizeof(zapnode));
  112. }
  113.  
  114. static void
  115. putx(void)
  116. {
  117.     if (zapcur != ERROR) {
  118.     dseek(zapdbx, zapcur * sizeof zapnode, SEEK_SET);
  119.     dwrite(zapdbx, &zapnode, sizeof(zapnode));
  120.     }
  121. }
  122.  
  123. /*
  124.  * close_zap() - close the zaploop database
  125.  */
  126. void
  127. close_zap(void)
  128. {
  129.     register i;
  130.  
  131.     if (nzmsg) {
  132.     for (i = 0; i < nzsize; i++)
  133.         if (nzmsg[i].mulast > 0L || nzmsg[i].mulastid > 0L) {
  134.         getx(nzmsg[i].muloc);
  135.         zapnode.lxlast = nzmsg[i].mulast;
  136.         zapnode.lxlastid = nzmsg[i].mulastid;
  137.         putx();
  138.         }
  139.     free(nzmsg);
  140.     nzmsg = NULL;
  141.     nzsize = 0;
  142.     }
  143.     if (zapdbx >= 0)
  144.     dclose(zapdbx);
  145.     zapdbx = -1;
  146. }
  147.  
  148. /*
  149.  * makebucket() -- make up a new zap entry for this address/room
  150.  */
  151. static int
  152. makebucket(char *address, char *name, short chain)
  153. {
  154.     long pos = dseek(zapdbx, 0L, SEEK_END);    /* seek to eof */
  155.  
  156.     if (pos >= 0)
  157.     pos /= sizeof zapnode;
  158.     zapcur = pos;
  159.     strcpy(zapnode.lxaddr, address);
  160.     strcpy(zapnode.lxname, name);
  161.     zapnode.lxlast = 0L;
  162.     zapnode.lxlastid = 0L;
  163.     zapnode.lxchain = chain;
  164.     zapnode.lxroom = thisRoom;
  165.     zapnode.lxgen = roomTab[thisRoom].rtgen;
  166.     putx();
  167.     return zapcur;
  168. }
  169.  
  170. /*
  171.  * loadx() -- load up the appropriate zap record for a node
  172.  */
  173. static int
  174. loadx(char *addr, char *name)
  175. {
  176.     register int i;
  177.     register short ahash = hash(addr);
  178.  
  179. #define    THIS(x)    (stricmp(x,zapnode.lxaddr) == 0 && zapnode.lxroom == thisRoom)
  180.  
  181.     if (addr[0] == 0 || strlen(addr) > 12)
  182.     return 0;
  183.     if (zapcur != ERROR && THIS(addr))
  184.     return 1;
  185.     for (i = 0; i < cfg.zap_count; i++)
  186.     if (ahash == zap[i].zhash) {
  187.         getx(zap[i].zbucket);
  188.         if (stricmp(addr, zapnode.lxaddr) != 0)
  189.         continue;
  190.         while (zapnode.lxroom != thisRoom && zapnode.lxchain >= 0)
  191.         getx(zapnode.lxchain);
  192.         if (zapnode.lxroom != thisRoom)
  193.         zap[i].zbucket = makebucket(addr, name, zap[i].zbucket);
  194.         else {    /* right room, so check gen */
  195.         if (zapnode.lxgen != roomTab[thisRoom].rtgen) {
  196.             zapnode.lxgen = roomTab[thisRoom].rtgen;   /* update gen */
  197.             zapnode.lxlast = zapnode.lxlastid = 0L;    /* reset */
  198.             putx();
  199.         }
  200.         }
  201.         return 1;
  202.     }
  203.     /*
  204.      * new node id -- add a new record
  205.      */
  206.     if (zap = (struct zaphash *)
  207.         realloc(zap, (1+cfg.zap_count) * sizeof(struct zaphash))) {
  208.     zap[cfg.zap_count].zhash = ahash;
  209.     zap[cfg.zap_count].zbucket = makebucket(addr, name, -1);
  210.     cfg.zap_count++;
  211.     printf("Created new zap entry for %s (%s)\n", msgBuf.mboname,
  212.         roomTab[thisRoom].rtname);
  213.     return 1;
  214.     }
  215.     fprintf(stderr, "(loadx) Out of memory.\n");
  216.     checkloops = 0;
  217.     return 0;
  218. }
  219.  
  220. /* 
  221.  * notseen() - looping message?
  222.  *
  223.  * Algorithm: We reject a message if:
  224.  * 
  225.  *   a) Its time & date is EARLIER than the latest message received AND
  226.  *    its message id is LESS THAN that of the latest message received, or
  227.  *   b) If the message has no id, we reject it iff its time & date is EARLIER.
  228.  *
  229.  * Extras: we ignore all messages bearing time/date stamps more than 1 day
  230.  * later than our current time.  This helps weed out messages which have come
  231.  * in from systems whose clocks have been screwed up.
  232.  */
  233. int
  234. notseen(void)
  235. {
  236.     time_t last = msgtime(msgBuf.mbdate, msgBuf.mbtime);
  237.     long lastid = msgBuf.mbsrcid;
  238.     LABEL chk;
  239.     int i;
  240.     struct mupdate *tmp;
  241.  
  242.     if (last == ERROR) {
  243.     printf("Message with unparsable date (%s %s) encountered\n",
  244.         msgBuf.mbdate, msgBuf.mbtime);
  245.     return 1;
  246.     }
  247.     if (last > today) {
  248.     printf("Message with spurious date (%s) encountered\n",
  249.         makedate(last, YES));
  250.     return 1;
  251.     }
  252.     if (lastid < 0L || lastid > 1000000L) {
  253.     printf("Message with invalid mbsrcid (%ld) encountered\n",
  254.         msgBuf.mbsrcid);
  255.     return 1;
  256.     }
  257.  
  258.     if (checkloops && normID(msgBuf.mborig, chk) && loadx(chk, msgBuf.mboname))
  259.     if (last > zapnode.lxlast || lastid > zapnode.lxlastid) {
  260.         for (i = 0; i < nzsize; i++)
  261.         if (nzmsg[i].muloc == zapcur)  {
  262.             if (last > nzmsg[i].mulast)
  263.             nzmsg[i].mulast = last;
  264.             if (lastid > nzmsg[i].mulastid)
  265.             nzmsg[i].mulastid = lastid;
  266.             return 1;        
  267.         }
  268.         tmp = (struct mupdate *)
  269.         realloc(nzmsg, (1 + nzsize) * sizeof(struct mupdate));
  270.         if (tmp) {
  271.         nzmsg = tmp;
  272.         nzmsg[nzsize].mulast    = last;
  273.         nzmsg[nzsize].mulastid    = lastid;
  274.         nzmsg[nzsize].muloc    = zapcur;
  275.         ++nzsize;
  276.         return 1;
  277.         }
  278.         fprintf(stderr, "(loopzapper) out of memory\n");
  279.         checkloops = 0;
  280.     }
  281.     else
  282.         return 0;
  283.     return 1;
  284. }
  285.  
  286. /*
  287.  * doMessages() -- loops thru msg file until finished.
  288.  */
  289. void
  290. doMessages(void)
  291. {
  292.     long msg, first;
  293.     int total = 0;         /* For stat keeping. */
  294.     PATHBUF msgFile;
  295.     struct tm *cur;
  296.  
  297.     if (zap) {
  298.     free(zap);
  299.     zap = (struct zaphash *)malloc(sizeof *zap);
  300.     }
  301.     cfg.zap_count = 0;
  302.     init_zap();
  303.     today = time(NULL) + (24 * 60 * 60);    /* add an extra day */
  304.  
  305.     ctdlfile(msgFile, cfg.msgdir, "ctdlmsg.sys");
  306.     if ((msgfl = dopen(msgFile, O_RDWR)) < 0)
  307.     crashout("no %s", msgFile);
  308.  
  309.     msgseek(0, 0);
  310.     getmessage();
  311.     printf("Msg #%ld (srcid %ld) %s%s%s (%s) %s %s\n", msgBuf.mbid,
  312.     msgBuf.mbsrcid, msgBuf.mbauth, msgBuf.mboname[0] ? "@" : "", 
  313.     msgBuf.mboname, msgBuf.mbroom, msgBuf.mbdate, msgBuf.mbtime);
  314.     first = msgBuf.mbid;
  315.     if (roomAt(msgBuf.mbroom) > AIDEROOM)
  316.     notseen();
  317.     
  318.     total = 1;
  319.     do {
  320.     total++;
  321.     getmessage();
  322.     printf("Msg #%ld (srcid %ld) %s%s%s (%s) %s %s\n", msgBuf.mbid,
  323.         msgBuf.mbsrcid, msgBuf.mbauth, msgBuf.mboname[0] ? "@" : "", 
  324.         msgBuf.mboname, msgBuf.mbroom, msgBuf.mbdate, msgBuf.mbtime);
  325.     msg = msgBuf.mbid;
  326.     if (roomAt(msgBuf.mbroom) > AIDEROOM)
  327.         notseen();
  328.     } while (msg != first);
  329.     printf("%d messages seen\n", total);
  330.  
  331.     close_zap();
  332.  
  333.     printf("%d systems in zaptable\n", cfg.zap_count);
  334. }
  335.  
  336. main()
  337. {
  338.     printf("%s for Fnordadel V%s\n", program, VERSION);
  339.     if (readSysTab(YES)) {
  340.     doMessages();
  341.     printf("wrote %d bytes to ctdltabl.sys\n", writeSysTab());
  342.     }
  343.     if (fromdesk())
  344.     hitkey();
  345. }
  346.